# Python 3 高级语法
# 列表推导式
a = [x for x in range(10)] # 生成一个列表，包含 0 到 9 的数字
print(a) # 输出 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 生成器表达式
a = (x for x in range(10)) # 生成一个生成器，包含 0 到 9 的数字
print(a) # 输出 <generator object <genexpr> at 0x7f8c80000000> (生成器对象)

# 字典推导式
a = {x: x**2 for x in range(10)} # 生成一个字典，包含 0 到 9 的数字，每个数字的平方作为值
print(a) # 输出 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

# 集合推导式
a = {x for x in range(10)} # 生成一个集合，包含 0 到 9 的数字
print(a) # 输出 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# 装饰器
def my_decorator(func): # 定义一个装饰器函数，接收一个函数作为参数
    def wrapper(): # 定义一个包装函数，接收任意参数
        print("Before function call") # 在函数调用前输出
        func() # 调用函数
        print("After function call") # 在函数调用后输出
    return wrapper # 返回包装函数

@my_decorator # 装饰器，等价于 my_function = my_decorator(my_function)
def my_function(): # 定义一个函数
    print("Inside function") # 输出

my_function() # 调用函数，输出 "Before function call" "Inside function" "After function call"

# 上下文管理器
class MyContextManager: # 定义一个上下文管理器类
    def __enter__(self): # 进入上下文管理器
        print("Entering context") # 输出
        return self # 返回自身

    def __exit__(self, exc_type, exc_value, traceback): # 退出上下文管理器
        print("Exiting context") # 输出

    def do_something(self): # 定义一个方法
        print("Doing something") # 输出

with MyContextManager() as context: # 进入上下文管理器，将上下文管理器对象赋值给 context 变量
    context.do_something() # 调用方法，输出 "Entering context" "Doing something" "Exiting context"

# 异常处理
try: # 尝试执行
    a = 1 / 0 # 抛出异常
except ZeroDivisionError as e: # 捕获异常
    print("Error:", e) # 输出异常信息，输出 "Error: division by zero" (ZeroDivisionError 异常)
else: # 如果没有异常
    print("No error") # 输出 "No error"
finally: # 无论是否有异常，都会执行
    print("File closed") # 输出关闭信息，输出 "File closed"

# 迭代器
class MyIterator: # 定义一个迭代器类
    def __init__(self, max): # 构造函数，接收一个参数
        self.max = max # 实例属性

    def __iter__(self): # 返回迭代器对象
        self.n = 0 # 初始化
        return self # 返回自身

    def __next__(self): # 返回下一个元素 (迭代器协议)
        if self.n <= self.max: # 如果 n 小于等于 max
            result = self.n # 保存 n 的值
            self.n += 1 # 自增 1
            return result # 返回 n 的值
        else: # 如果 n 大于 max
            raise StopIteration # 抛出 StopIteration 异常

my_iterator = MyIterator(5) # 创建一个迭代器对象，包含 0 到 5 的数字
for i in my_iterator: # 遍历迭代器对象
    print(i) # 输出 0 到 5 的数字，输出 0 1 2 3 4 5 (StopIteration 异常)

# 生成器
def my_generator(max): # 定义一个生成器函数，接收一个参数
    n = 0 # 初始化
    while n <= max: # 循环，直到 n 大于 max
        yield n # 生成 n 的值
        n += 1 # 自增 1

my_generator = my_generator(5) # 创建一个生成器对象，包含 0 到 5 的数字
for i in my_generator: # 遍历生成器对象
    print(i) # 输出 0 到 5 的数字，输出 0 1 2 3 4 5 (StopIteration 异常)

# 多线程
import threading # 导入 threading 模块

def my_function(): # 定义一个函数
    print("Thread started") # 输出
    print("Thread finished") # 输出

my_thread = threading.Thread(target=my_function) # 创建一个线程对象，指定目标函数为 my_function
my_thread.start() # 启动线程，输出 "Thread started" (线程启动)
my_thread.join() # 等待线程结束，输出 "Thread finished" (线程结束)

# 多进程
import multiprocessing # 导入 multiprocessing 模块

def my_function(): # 定义一个函数
    print("Process started") # 输出
    print("Process finished") # 输出

my_process = multiprocessing.Process(target=my_function) # 创建一个进程对象，指定目标函数为 my_function
my_process.start() # 启动进程，输出 "Process started" (进程启动)
my_process.join() # 等待进程结束，输出 "Process finished" (进程结束) 

# 异步编程
import asyncio # 导入 asyncio 模块

async def my_function(): # 定义一个异步函数，使用 async 关键字
    print("Async function started") # 输出
    await asyncio.sleep(1) # 等待 1 秒 (异步等待)
    print("Async function finished") # 输出

async def main(): # 定义一个异步函数，使用 async 关键字
    print("Main function started") # 输出
    await my_function() # 调用异步函数，输出 "Async function started" (异步等待) "Async function finished" (异步等待)
    print("Main function finished") # 输出

asyncio.run(main()) # 运行异步函数，输出 "Main function started" "Async function started" "Async function finished" "Main function finished" (异步等待)